package site.sorghum.ddl.extra;

public class Convert {

    /**
     * 将对象转换为字符串
     *
     * @param value 要转换的对象
     * @return 字符串结果，如果为null则返回null
     */
    public static String toString(Object value) {
        return value == null ? null : value.toString();
    }

    /**
     * 将对象转换为字符串，如果为null则返回默认值
     *
     * @param value        要转换的对象
     * @param defaultValue 默认值
     * @return 字符串结果
     */
    public static String toString(Object value, String defaultValue) {
        return value == null ? defaultValue : value.toString();
    }

    /**
     * 将对象转换为int
     *
     * @param value 要转换的对象
     * @return int值，转换失败返回0
     */
    public static int toInt(Object value) {
        return toInt(value, 0);
    }

    /**
     * 将对象转换为int，如果转换失败则返回默认值
     *
     * @param value        要转换的对象
     * @param defaultValue 默认值
     * @return int值
     */
    public static int toInt(Object value, int defaultValue) {
        if (value == null) {
            return defaultValue;
        }
        try {
            if (value instanceof Number) {
                return ((Number) value).intValue();
            }
            return Integer.parseInt(toString(value).trim());
        } catch (Exception e) {
            return defaultValue;
        }
    }

    /**
     * 将对象转换为long
     *
     * @param value 要转换的对象
     * @return long值，转换失败返回0L
     */
    public static long toLong(Object value) {
        return toLong(value, 0L);
    }

    /**
     * 将对象转换为long，如果转换失败则返回默认值
     *
     * @param value        要转换的对象
     * @param defaultValue 默认值
     * @return long值
     */
    public static long toLong(Object value, long defaultValue) {
        if (value == null) {
            return defaultValue;
        }
        try {
            if (value instanceof Number) {
                return ((Number) value).longValue();
            }
            return Long.parseLong(toString(value).trim());
        } catch (Exception e) {
            return defaultValue;
        }
    }

    /**
     * 将对象转换为float
     *
     * @param value 要转换的对象
     * @return float值，转换失败返回0.0f
     */
    public static float toFloat(Object value) {
        return toFloat(value, 0.0f);
    }

    /**
     * 将对象转换为float，如果转换失败则返回默认值
     *
     * @param value        要转换的对象
     * @param defaultValue 默认值
     * @return float值
     */
    public static float toFloat(Object value, float defaultValue) {
        if (value == null) {
            return defaultValue;
        }
        try {
            if (value instanceof Number) {
                return ((Number) value).floatValue();
            }
            return Float.parseFloat(toString(value).trim());
        } catch (Exception e) {
            return defaultValue;
        }
    }

    /**
     * 将对象转换为double
     *
     * @param value 要转换的对象
     * @return double值，转换失败返回0.0
     */
    public static double toDouble(Object value) {
        return toDouble(value, 0.0);
    }

    /**
     * 将对象转换为double，如果转换失败则返回默认值
     *
     * @param value        要转换的对象
     * @param defaultValue 默认值
     * @return double值
     */
    public static double toDouble(Object value, double defaultValue) {
        if (value == null) {
            return defaultValue;
        }
        try {
            if (value instanceof Number) {
                return ((Number) value).doubleValue();
            }
            return Double.parseDouble(toString(value).trim());
        } catch (Exception e) {
            return defaultValue;
        }
    }

    /**
     * 将对象转换为boolean
     *
     * @param value 要转换的对象
     * @return boolean值，转换失败返回false
     */
    public static boolean toBoolean(Object value) {
        return toBoolean(value, false);
    }

    /**
     * 将对象转换为boolean，如果转换失败则返回默认值
     *
     * @param value        要转换的对象
     * @param defaultValue 默认值
     * @return boolean值
     */
    public static boolean toBoolean(Object value, boolean defaultValue) {
        if (value == null) {
            return defaultValue;
        }
        if (value instanceof Boolean) {
            return (Boolean) value;
        }
        String strValue = toString(value).trim().toLowerCase();
        if (strValue.equals("true") || strValue.equals("1") || strValue.equals("yes") || strValue.equals("on")) {
            return true;
        }
        if (strValue.equals("false") || strValue.equals("0") || strValue.equals("no") || strValue.equals("off")) {
            return false;
        }
        return defaultValue;
    }

    /**
     * 将对象转换为char
     *
     * @param value 要转换的对象
     * @return char值，转换失败返回'\u0000'
     */
    public static char toChar(Object value) {
        return toChar(value, '\u0000');
    }

    /**
     * 将对象转换为char，如果转换失败则返回默认值
     *
     * @param value        要转换的对象
     * @param defaultValue 默认值
     * @return char值
     */
    public static char toChar(Object value, char defaultValue) {
        if (value == null) {
            return defaultValue;
        }
        if (value instanceof Character) {
            return (Character) value;
        }
        String strValue = toString(value);
        if (strValue.length() == 1) {
            return strValue.charAt(0);
        }
        return defaultValue;
    }

    /**
     * 将对象转换为byte
     *
     * @param value 要转换的对象
     * @return byte值，转换失败返回0
     */
    public static byte toByte(Object value) {
        return toByte(value, (byte) 0);
    }

    /**
     * 将对象转换为byte，如果转换失败则返回默认值
     *
     * @param value        要转换的对象
     * @param defaultValue 默认值
     * @return byte值
     */
    public static byte toByte(Object value, byte defaultValue) {
        if (value == null) {
            return defaultValue;
        }
        try {
            if (value instanceof Number) {
                return ((Number) value).byteValue();
            }
            return Byte.parseByte(toString(value).trim());
        } catch (Exception e) {
            return defaultValue;
        }
    }

    /**
     * 将对象转换为short
     *
     * @param value 要转换的对象
     * @return short值，转换失败返回0
     */
    public static short toShort(Object value) {
        return toShort(value, (short) 0);
    }

    /**
     * 将对象转换为short，如果转换失败则返回默认值
     *
     * @param value        要转换的对象
     * @param defaultValue 默认值
     * @return short值
     */
    public static short toShort(Object value, short defaultValue) {
        if (value == null) {
            return defaultValue;
        }
        try {
            if (value instanceof Number) {
                return ((Number) value).shortValue();
            }
            return Short.parseShort(toString(value).trim());
        } catch (Exception e) {
            return defaultValue;
        }
    }

}